#include<iostream>
#include<vector>
#include<queue>
#include<cstdlib>
#include<time.h>
#include<stdio.h>
using namespace std;

#define forn(i,n) for(int i=0;i<(n);i++)
#define fornr(i,n) for(int i=(n)-1;i>=0;i--)

#define O(o) contador+=(o);

#define W 1
#define S 2
#define E 4
#define N 8
#define I 16

#define INF 0x7FFFFFFF

enum Dir {V,H};

struct Valla{
        int x, y, w, h;
        Dir d;
};

typedef vector<Valla> vv;
typedef vector<int> vint;
typedef vector<vint> vvint;

/* el contador de operaciones */
long long int contador = 0;

int flood(vv&, int minX, int maxX, int minY, int maxY);

int main(int argc, char** argv){

        /* timers para las mediciones */
        clock_t start,end;

        /* h = altura ; n = #vallas */
        int h, n;

        while(cin >> h >> n && !(h==-1 && n==-1)){

                int minX = INF;
                int minY = INF;
                int mx = 0;
                int my = 0;
                vv v;

                /* Por cada valla */
                forn(i,n){
                        char c;

                        /* Armo la valla */
                        Valla aux;
                        cin >> aux.x;
                        cin >> aux.y;
                        cin >> c;
                        aux.d = (c=='-' ? H : V);
                        cin >> aux.w;
                        cin >> aux.h;

                        /* Si la valla frena la marea */
                        if(h <= aux.h){

                                v.push_back(aux);

                                /* Actualizo los limites */
                                minX = min(minX,aux.x);
                                minY = min(minY,aux.y);
                                mx = max(mx,aux.x + (aux.d==H ? aux.w : 0) );
                                my = max(my,aux.y + (aux.d==V ? aux.w : 0) );

                        }

                }
               
                if(argc>1 && string(argv[1])=="time"){
                /* si el primer argumento es "time" mido tiempos.. */

                        /* lo ejecuto hasta que tarde al menos secs segundos, para tener presicion (0.5 por default) */
                        float secs=argc>2?secs=atof(argv[2]):0.5;

                         /* tomo el tiempo times veces por dato de entrada, para disminuir el error */
                        int tries=argc>3?tries=atoi(argv[3]):1;
                        forn(tr,tries){
                                start = clock();        //guardo el tiempo
                                long long int cont=0;

                                /* Evaluo la funcion hasta que tarde al menos secs */
                                while((double)(clock()-start)/CLOCKS_PER_SEC<secs){
                                        flood(v,minX,mx,minY,my);
                                        cont++;
                                }

                                end = clock();          //guardo el tiempo de finalizacion

                                /* El tiempo total de evaluacion es lo_que_tardo/cantidad_de_veces_que_lo_llamo */
                                double tiempo=(double)(end-start)/(CLOCKS_PER_SEC*cont);

                                /* Imprimo el resultado con 8 decimales de presicion */
                                printf("%.8f ",tiempo);
                        }

                        cout << endl;
                       
                }else if(argc>1 && string(argv[1])=="count"){
                /* si el argumento es "count", cuento cantidad de operaciones.. */

                        contador=0;
                        flood(v,minX,mx,minY,my);
                        cout << contador << endl; //imprimo la cuenta
                       
                }else{
                /* Sino corro el algoritmo normal */

                        cout << flood(v,minX,mx,minY,my) << endl;

                }
        }
        return 0;
}

void print_map(vvint& m){
        fornr(i,m.size()){
                forn(j,m[i].size()) cout << m[i][j] << " ";
                cout << endl;
        }
}

void print_flood(vvint& m){
        fornr(i,m.size()){
                forn(j,m[i].size()) cout << (m[i][j] < I ? 'X' : '.');
                cout << endl;
        }
}

int flood(vv& v, int minX, int maxX, int minY, int maxY){

        /* Agrego los bordes extra */
        minX--; maxX++;
        minY--; maxY++; O(2)

        /* Si hay menos de 4 vallas se inunda todo seguro */
        if(v.size()<4) return 0;

        vvint mapa(maxY-minY,vint(maxX-minX,0)); O((maxY-minY)*(maxX-minX))

        /* Para cada valla */
        forn(i,v.size()){
                if(v[i].d==V){

                        /* Si la valla es vertical */
                        for(int k = v[i].y ; k < v[i].y + v[i].w; k++){
                                /* marco las celdas a derecha e izquierda */
                                if(v[i].x > minX) mapa[k-minY][v[i].x-1-minX] += E;
                                if(v[i].x < maxX) mapa[k-minY][ v[i].x-minX ] += W; O(4)
                        }

                }else{

                        /* Si la valla es horizontal */
                        for(int k = v[i].x ; k < v[i].x + v[i].w; k++){
                                /* marco las celdas arriba y abajo */
                                if(v[i].y > minY) mapa[v[i].y-1-minY][k-minX] += N;
                                if(v[i].y < maxY) mapa[ v[i].y-minY ][k-minX] += S; O(4)
                        }

                }
                O(2)
        }


        /* BFS */

        int supSeca = (mapa.size())*(mapa[0].size());
        queue<int> q;

        /* Meto el (0,0) en la cola porque segurom se inunda */
        q.push(0); q.push(0); mapa[0][0] += I; supSeca--; O(3)

        while(!q.empty()){

                /* Saco el proximo */
                int x = q.front(); q.pop();
                int y = q.front(); q.pop();

                /* Inundo si puedo la celda al N */
                if( y < mapa.size()-1 && !(mapa[y][x] & N) && mapa[y+1][x] < I ){
                        q.push(x); q.push(y+1); mapa[y+1][x] += I; supSeca--;
                }

                /* Inundo si puedo la celda al S */
                if( 0 < y && !(mapa[y][x] & S) && mapa[y-1][x] < I ){
                        q.push(x); q.push(y-1); mapa[y-1][x] += I; supSeca--;
                }


                /* Inundo si puedo la celda al E */
                if( x < mapa[y].size()-1 && !(mapa[y][x] & E) && mapa[y][x+1] < I ){
                         q.push(x+1); q.push(y); mapa[y][x+1] += I; supSeca--;
                }

                /* Inundo si puedo la celda al W */
                if( 0 < x && !(mapa[y][x] & W) && mapa[y][x-1] < I ){
                        q.push(x-1); q.push(y); mapa[y][x-1] += I; supSeca--;
                }

                O(7)
        }
        return supSeca;
}
